/**
 * 坐骑系统完整测试脚本
 * 测试所有坐骑相关指令：4420(训练)、4425(出战/休息)、4419(查看当前出战坐骑)、4423(坐骑列表)、4424(玩家坐骑列表)
 */

const http = require('http');
const WebSocket = require('ws');

// 测试配置
const CONFIG = {
    server: {
        host: 'localhost',
        port: 3000,
        protocol: 'http'
    },

    // 测试用户信息
    testUser: {
        mobile: '17091271111',
        password: '123456',
        passwordHash: 'e10adc3949ba59abbe56e057f20f883e' // 123456的SHA256
    },

    // 测试角色信息
    testCharacter: {
        name: '坐骑测试角色',
        sex: 1, // 1:男, 0:女
        roleType: 1, // 1:武士, 2:文人, 3:异师
        headIndex: 2
    }
};

class MountSystemTester {
    constructor() {
        this.token = null;
        this.userId = null;
        this.ws = null;
        this.characters = [];
        this.selectedCharacter = null;
        this.testResults = [];
        this.mountListData = null;
        this.playerMountsData = null;
        this.activeMountData = null;
    }

    // 运行完整测试流程
    async runTest() {
        console.log('🐎 开始坐骑系统完整测试...\n');
        console.log('测试目标：HTTP登录 → WebSocket连接 → 选择角色 → 测试所有坐骑指令\n');

        try {
            // 1. HTTP登录
            await this.testHttpLogin();

            // 2. 建立WebSocket连接
            await this.testWebSocketConnection();

            // 3. 查询角色列表
            await this.testQueryCharacters();

            // 4. 如果没有角色，先创建角色
            if (this.characters.length === 0) {
                await this.testCreateCharacter();
                // 重新查询角色列表
                await this.testQueryCharacters();
            }

            // 5. 选择角色
            await this.testSelectCharacter();

            // 6. 测试4423指令 - 获取坐骑列表
            await this.testCode4423MountList();

            // 7. 测试4424指令 - 获取玩家坐骑列表
            await this.testCode4424PlayerMounts();

            // 8. 测试4424指令 - 购买坐骑
            await this.testCode4424PurchaseMount();

            // 8.5. 重新获取玩家坐骑列表（购买后）
            await this.testCode4424PlayerMountsAfterPurchase();

            // 9. 测试4419指令 - 查看当前出战坐骑信息
            await this.testCode4419ActiveMount();

            // 10. 测试4425指令 - 坐骑出战/休息
            await this.testCode4425MountStatus();

            // 11. 测试4420指令 - 训练坐骑
            await this.testCode4420TrainMount();

            // 12. 验证数据结构完整性
            await this.validateDataStructure();

            // 13. 断开连接
            await this.testDisconnect();

            // 输出测试结果
            this.printTestResults();

        } catch (error) {
            console.error('❌ 测试过程中发生错误:', error.message);
            this.addTestResult('整体测试', false, error.message);
        }
    }

    // 1. HTTP登录测试
    async testHttpLogin() {
        console.log('🔐 步骤1: HTTP登录测试...');

        try {
            // 首先尝试注册用户（如果不存在）
            await this.registerUser();

            // 执行登录
            const loginData = await this.makeHttpRequest('/user-service/user/login', 'POST', {
                mobile: CONFIG.testUser.mobile,
                pwd: CONFIG.testUser.passwordHash
            });

            if (loginData.code === 0 && loginData.data) {
                this.userId = loginData.data.userId;
                this.token = loginData.data.accessToken;

                console.log(`✅ 登录成功: userId=${this.userId}, token=${this.token.substring(0, 8)}...`);
                this.addTestResult('HTTP登录', true, `用户ID: ${this.userId}`);
            } else {
                throw new Error(`登录失败: ${loginData.msg || '未知错误'}`);
            }

        } catch (error) {
            console.log('❌ 登录失败:', error.message);
            this.addTestResult('HTTP登录', false, error.message);
            throw error;
        }
    }

    // 注册用户（如果不存在）
    async registerUser() {
        try {
            const res = await this.makeHttpRequest('/user-service/user/register', 'POST', {
                mobile: CONFIG.testUser.mobile,
                pwd: CONFIG.testUser.passwordHash,
                captcha: '123456' // 模拟验证码
            });
            console.log('📝 用户注册成功', res);
        } catch (error) {
            // 如果用户已存在，忽略错误
            if (error.message.includes('MOBILE_EXISTS') || error.message.includes('已存在')) {
                console.log('👤 用户已存在，跳过注册');
            } else {
                console.log('⚠️ 注册失败:', error.message);
            }
        }
    }

    // 2. WebSocket连接测试
    async testWebSocketConnection() {
        console.log('\n🔌 步骤2: WebSocket连接测试...');

        return new Promise((resolve, reject) => {
            try {
                const wsUrl = `ws://${CONFIG.server.host}:${CONFIG.server.port}/user-service/websocket?t=${this.token}`;
                this.ws = new WebSocket(wsUrl);

                this.ws.on('open', async () => {
                    console.log('✅ WebSocket连接成功');
                    this.addTestResult('WebSocket连接', true, '连接建立成功');

                    // 设置消息监听器
                    this.setupMessageHandler();

                    // 等待连接完全稳定
                    await this.delay(500);
                    resolve();
                });

                this.ws.on('error', (error) => {
                    console.log('❌ WebSocket连接失败:', error.message);
                    this.addTestResult('WebSocket连接', false, error.message);
                    reject(error);
                });

                this.ws.on('close', () => {
                    console.log('🔌 WebSocket连接已关闭');
                });

                // 连接超时
                setTimeout(() => {
                    if (this.ws.readyState === WebSocket.CONNECTING) {
                        this.ws.close();
                        reject(new Error('连接超时'));
                    }
                }, 10000);

            } catch (error) {
                reject(error);
            }
        });
    }

    // 设置消息处理器
    setupMessageHandler() {
        this.ws.on('message', (data) => {
            try {
                const message = JSON.parse(data.toString());
                console.log('📨 收到消息:', JSON.stringify(message, null, 2));

                // 根据act_id处理不同类型的响应
                this.handleWebSocketResponse(message);

            } catch (error) {
                console.error('❌ 消息解析失败:', error.message);
            }
        });
    }

    // 处理WebSocket响应
    handleWebSocketResponse(message) {
        const { act_id, code, roleList, roleCount, data, msg } = message;

        switch (act_id) {
            case 3: // 查询角色列表响应
                if (roleList && Array.isArray(roleList)) {
                    this.characters = roleList;
                    console.log(`📋 获取到${roleCount || roleList.length}个角色`);
                }
                break;

            case 4: // 角色选择响应
                if (code === 0) {
                    console.log('🎯 角色选择成功');
                }
                break;

            case 5: // 角色创建响应（兼容格式）
                if (code === 0) {
                    console.log('🆕 角色创建成功');
                }
                break;

            case 390: // 角色创建响应（标准指令）
                if (code === 0) {
                    console.log('🆕 角色创建成功');
                }
                break;

            case 4423: // 坐骑列表响应
                this.mountListData = {
                    act_id: message.act_id,
                    code: message.code,
                    data: message.data || [],
                    timestamp: new Date().toISOString()
                };
                console.log(`🐎 坐骑列表数据接收:`, JSON.stringify(this.mountListData, null, 2));
                break;

            case 4424: // 玩家坐骑列表响应
                this.playerMountsData = {
                    act_id: message.act_id,
                    code: message.code,
                    data: message.data || [],
                    timestamp: new Date().toISOString()
                };
                console.log(`🐎 玩家坐骑列表数据接收:`, JSON.stringify(this.playerMountsData, null, 2));
                break;

            case 4419: // 当前出战坐骑信息响应
                this.activeMountData = {
                    act_id: message.act_id,
                    code: message.code,
                    data: message.data || null,
                    timestamp: new Date().toISOString()
                };
                console.log(`🐎 当前出战坐骑数据接收:`, JSON.stringify(this.activeMountData, null, 2));
                break;

            case 4425: // 坐骑状态设置响应
                console.log(`🐎 坐骑状态设置响应:`, JSON.stringify(message, null, 2));
                break;

            case 4420: // 坐骑训练响应
                console.log(`🐎 坐骑训练响应:`, JSON.stringify(message, null, 2));
                break;

            default:
                // 记录其他消息但不处理
                break;
        }
    }

    // 3. 查询角色列表
    async testQueryCharacters() {
        console.log('\n📋 步骤3: 查询角色列表...');

        return new Promise(async (resolve) => {
            if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
                this.addTestResult('查询角色列表', false, 'WebSocket未连接');
                resolve();
                return;
            }

            // 等待WebSocket连接稳定
            await this.delay(1000);

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 3) {
                        this.ws.removeListener('message', responseHandler);

                        if (message.roleList && Array.isArray(message.roleList)) {
                            this.characters = message.roleList;
                            console.log(`✅ 查询成功，共${message.roleCount || message.roleList.length}个角色`);
                            this.addTestResult('查询角色列表', true, `获取${this.characters.length}个角色`);
                        } else {
                            // 即使没有角色，也算查询成功
                            this.characters = [];
                            console.log('✅ 查询成功，暂无角色');
                            this.addTestResult('查询角色列表', true, '获取0个角色');
                        }
                        resolve();
                    }
                } catch (error) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('查询角色列表', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送查询角色列表请求
            this.ws.send(JSON.stringify({
                c: 3,
                d: null
            }));

            // 设置超时
            setTimeout(() => {
                this.ws.removeListener('message', responseHandler);
                this.addTestResult('查询角色列表', false, '请求超时');
                resolve();
            }, 10000);
        });
    }

    // 4. 创建角色测试
    async testCreateCharacter() {
        console.log('\n🆕 步骤4: 创建角色测试...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('创建角色', false, 'WebSocket未连接');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;
            let retryCount = 0;
            const maxRetries = 2;

            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    console.log(`📨 收到创建角色响应:`, JSON.stringify(message, null, 2));

                    if (message.act_id === 5 || message.act_id === 390) { // 兼容格式或标准指令
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 角色创建成功');
                            this.addTestResult('创建角色', true, '角色创建成功');

                            // 等待一段时间让服务器处理角色创建
                            setTimeout(() => {
                                resolve();
                            }, 2000);
                        } else {
                            const errorMsg = message.msg || '未知错误';
                            console.log(`❌ 角色创建失败: ${errorMsg}`);

                            // 如果是角色名重复，尝试使用不同的名字
                            if (errorMsg.includes('重复') || errorMsg.includes('已存在') || errorMsg.includes('DUPLICATE')) {
                                if (retryCount < maxRetries) {
                                    retryCount++;
                                    const newName = `${CONFIG.testCharacter.name}_${Date.now()}`;
                                    console.log(`🔄 角色名重复，尝试使用新名字: ${newName}`);

                                    // 重新发送创建角色请求
                                    setTimeout(() => {
                                        this.createCharacterWithName(newName, resolve);
                                    }, 1000);
                                    return;
                                }
                            }

                            this.addTestResult('创建角色', false, errorMsg);
                            resolve();
                        }
                    }
                } catch (error) {
                    console.error('❌ 创建角色响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('创建角色', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送创建角色请求
            this.createCharacterWithName(CONFIG.testCharacter.name, resolve);

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('创建角色', false, '请求超时');
                    resolve();
                }
            }, 15000);
        });
    }

    // 使用指定名字创建角色
    createCharacterWithName(name, resolve) {
        const createData = {
            c: 5, // 兼容格式
            d: {
                name: name,
                sex: CONFIG.testCharacter.sex,
                roleType: CONFIG.testCharacter.roleType,
                headIndex: CONFIG.testCharacter.headIndex
            }
        };

        console.log(`📤 发送创建角色请求:`, JSON.stringify(createData, null, 2));
        this.ws.send(JSON.stringify(createData));
    }

    // 5. 选择角色
    async testSelectCharacter() {
        console.log('\n🎯 步骤5: 选择角色...');

        if (this.characters.length === 0) {
            console.log('⚠️ 没有可选择的角色');
            this.addTestResult('选择角色', false, '没有可用角色');
            return;
        }

        return new Promise((resolve) => {
            if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
                this.addTestResult('选择角色', false, 'WebSocket未连接');
                resolve();
                return;
            }

            // 选择第一个角色
            const targetCharacter = this.characters[0];

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4) {
                        this.ws.removeListener('message', responseHandler);

                        if (message.code === 0) {
                            this.selectedCharacter = targetCharacter;
                            console.log(`✅ 角色选择成功: ${targetCharacter.name} (ID: ${targetCharacter.id})`);
                            this.addTestResult('选择角色', true, `选择角色: ${targetCharacter.name}`);

                            // 等待服务器处理角色选择
                            setTimeout(() => {
                                resolve();
                            }, 2000);
                        } else {
                            console.log(`❌ 角色选择失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('选择角色', false, message.msg || '选择失败');
                            resolve();
                        }
                    }
                } catch (error) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('选择角色', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送选择角色请求
            this.ws.send(JSON.stringify({
                c: 4,
                d: {
                    characterId: targetCharacter.id
                }
            }));

            // 设置超时
            setTimeout(() => {
                this.ws.removeListener('message', responseHandler);
                this.addTestResult('选择角色', false, '请求超时');
                resolve();
            }, 10000);
        });
    }

    // 6. 测试4423指令 - 获取坐骑列表
    async testCode4423MountList() {
        console.log('\n🐎 步骤6: 测试4423指令 - 获取坐骑列表...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4423坐骑列表测试', false, 'WebSocket未连接');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4423) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4423坐骑列表查询成功');
                            console.log(`🐎 坐骑数量: ${message.data ? message.data.length : 0}`);

                            // 验证基础数据结构
                            if (message.data && Array.isArray(message.data)) {
                                console.log('✅ 坐骑列表数据结构验证通过');
                                this.addTestResult('4423坐骑列表测试', true, `获取${message.data.length}个坐骑`);

                                // 显示坐骑列表详情
                                if (message.data.length > 0) {
                                    console.log('📋 坐骑列表详情:');
                                    message.data.forEach((mount, index) => {
                                        console.log(`  ${index + 1}. ${mount.n} (ID:${mount.id}, 状态:${mount.s}, 类型:${mount.t})`);
                                    });
                                }
                            } else {
                                console.log('❌ 坐骑列表数据结构验证失败');
                                this.addTestResult('4423坐骑列表测试', false, '返回数据格式错误');
                            }
                        } else {
                            console.log(`❌ 4423坐骑列表查询失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4423坐骑列表测试', false, message.msg || '查询失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4423坐骑列表响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4423坐骑列表测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4423请求
            const requestData = {
                c: 4423,
                d: null
            };

            console.log(`📤 发送4423请求:`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4423坐骑列表测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 7. 测试4424指令 - 获取玩家坐骑列表
    async testCode4424PlayerMounts() {
        console.log('\n🐎 步骤7: 测试4424指令 - 获取玩家坐骑列表...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4424玩家坐骑列表测试', false, 'WebSocket未连接');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4424) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4424玩家坐骑列表查询成功');
                            console.log(`🐎 玩家坐骑数量: ${message.data ? message.data.length : 0}`);

                            // 验证基础数据结构
                            if (message.data && Array.isArray(message.data)) {
                                console.log('✅ 玩家坐骑列表数据结构验证通过');
                                this.addTestResult('4424玩家坐骑列表测试', true, `获取${message.data.length}个玩家坐骑`);

                                // 显示玩家坐骑列表详情
                                if (message.data.length > 0) {
                                    console.log('📋 玩家坐骑列表详情:');
                                    message.data.forEach((mount, index) => {
                                        console.log(`  ${index + 1}. ${mount.name} (ID:${mount.id}, 等级:${mount.level}, 状态:${mount.status})`);
                                    });
                                } else {
                                    console.log('📋 玩家暂无坐骑');
                                }
                            } else {
                                console.log('❌ 玩家坐骑列表数据结构验证失败');
                                this.addTestResult('4424玩家坐骑列表测试', false, '返回数据格式错误');
                            }
                        } else {
                            console.log(`❌ 4424玩家坐骑列表查询失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4424玩家坐骑列表测试', false, message.msg || '查询失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4424玩家坐骑列表响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424玩家坐骑列表测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4424请求
            const requestData = {
                c: 4424,
                d: null
            };

            console.log(`📤 发送4424请求:`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424玩家坐骑列表测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 8. 测试4424指令 - 购买坐骑
    async testCode4424PurchaseMount() {
        console.log('\n🐎 步骤8: 测试4424指令 - 购买坐骑...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4424购买坐骑测试', false, 'WebSocket未连接');
            return;
        }

        // 选择第一个坐骑进行购买测试（除了免费的战马）
        let testMountId = null;
        if (this.mountListData && this.mountListData.data && this.mountListData.data.length > 0) {
            // 选择第一个需要购买的坐骑（价格大于0的）
            const availableMount = this.mountListData.data.find(mount => mount.g > 0);
            if (availableMount) {
                testMountId = availableMount.hid; // 使用hid作为坐骑基础ID
            }
        }

        if (!testMountId) {
            console.log('⚠️ 没有可购买的坐骑进行测试');
            this.addTestResult('4424购买坐骑测试', false, '没有可购买的坐骑');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4424) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4424坐骑购买成功');
                            console.log(`🐎 购买结果: ${message.msg || '购买完成'}`);
                            this.addTestResult('4424购买坐骑测试', true, '坐骑购买成功');
                        } else {
                            console.log(`❌ 4424坐骑购买失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4424购买坐骑测试', false, message.msg || '购买失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4424坐骑购买响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424购买坐骑测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4424请求 - 购买坐骑
            const requestData = {
                c: 4424,
                d: {
                    id: testMountId
                }
            };

            console.log(`📤 发送4424购买请求:`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424购买坐骑测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 8.5. 重新获取玩家坐骑列表（购买后）
    async testCode4424PlayerMountsAfterPurchase() {
        console.log('\n🐎 步骤8.5: 重新获取玩家坐骑列表（购买后）...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4424购买后玩家坐骑列表测试', false, 'WebSocket未连接');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4424) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4424购买后玩家坐骑列表查询成功');
                            console.log(`🐎 购买后玩家坐骑数量: ${message.data ? message.data.length : 0}`);

                            // 验证基础数据结构
                            if (message.data && Array.isArray(message.data)) {
                                console.log('✅ 购买后玩家坐骑列表数据结构验证通过');
                                this.addTestResult('4424购买后玩家坐骑列表测试', true, `获取${message.data.length}个玩家坐骑`);

                                // 显示玩家坐骑列表详情
                                if (message.data.length > 0) {
                                    console.log('📋 购买后玩家坐骑列表详情:');
                                    message.data.forEach((mount, index) => {
                                        console.log(`  ${index + 1}. ${mount.name} (ID:${mount.id}, 等级:${mount.level}, 状态:${mount.status})`);
                                    });

                                    // 更新玩家坐骑数据，供后续测试使用
                                    this.playerMountsData = {
                                        act_id: message.act_id,
                                        code: message.code,
                                        data: message.data || [],
                                        timestamp: new Date().toISOString()
                                    };
                                } else {
                                    console.log('📋 购买后玩家仍无坐骑');
                                }
                            } else {
                                console.log('❌ 购买后玩家坐骑列表数据结构验证失败');
                                this.addTestResult('4424购买后玩家坐骑列表测试', false, '返回数据格式错误');
                            }
                        } else {
                            console.log(`❌ 4424购买后玩家坐骑列表查询失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4424购买后玩家坐骑列表测试', false, message.msg || '查询失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4424购买后玩家坐骑列表响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424购买后玩家坐骑列表测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4424请求 - 获取玩家坐骑列表
            const requestData = {
                c: 4424,
                d: null
            };

            console.log(`📤 发送4424购买后列表请求:`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4424购买后玩家坐骑列表测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 9. 测试4419指令 - 查看当前出战坐骑信息
    async testCode4419ActiveMount() {
        console.log('\n🐎 步骤9: 测试4419指令 - 查看当前出战坐骑信息...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4419当前出战坐骑测试', false, 'WebSocket未连接');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4419) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4419当前出战坐骑查询成功');

                            if (message.data) {
                                console.log('🐎 当前出战坐骑信息:');
                                console.log(`  名称: ${message.data.name}`);
                                console.log(`  ID: ${message.data.id}`);
                                console.log(`  等级: ${message.data.lvl}`);
                                console.log(`  经验: ${message.data.exp}`);
                                console.log(`  生命: ${message.data.hp}`);
                                console.log(`  攻击: ${message.data.ap}`);
                                console.log(`  速度: ${message.data.sp}`);
                                console.log(`  法力: ${message.data.mp}`);

                                this.addTestResult('4419当前出战坐骑测试', true, `获取坐骑: ${message.data.name}`);
                            } else {
                                console.log('📋 当前没有出战坐骑');
                                this.addTestResult('4419当前出战坐骑测试', true, '当前没有出战坐骑');
                            }
                        } else {
                            console.log(`❌ 4419当前出战坐骑查询失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4419当前出战坐骑测试', false, message.msg || '查询失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4419当前出战坐骑响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4419当前出战坐骑测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4419请求
            const requestData = {
                c: 4419,
                d: null
            };

            console.log(`📤 发送4419请求:`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4419当前出战坐骑测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 10. 测试4425指令 - 坐骑出战/休息
    async testCode4425MountStatus() {
        console.log('\n🐎 步骤10: 测试4425指令 - 坐骑出战/休息...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4425坐骑状态设置测试', false, 'WebSocket未连接');
            return;
        }

        // 如果有玩家坐骑数据，使用第一个坐骑进行测试
        let testMountId = null;
        if (this.playerMountsData && this.playerMountsData.data && this.playerMountsData.data.length > 0) {
            testMountId = this.playerMountsData.data[0].id;
        } else if (this.mountListData && this.mountListData.data && this.mountListData.data.length > 0) {
            // 如果没有玩家坐骑，使用坐骑列表中的第一个坐骑（假设已购买）
            const availableMount = this.mountListData.data.find(mount => mount.s !== 0);
            if (availableMount) {
                testMountId = availableMount.id;
            }
        }

        if (!testMountId) {
            console.log('⚠️ 没有可用的坐骑进行状态设置测试');
            this.addTestResult('4425坐骑状态设置测试', false, '没有可用坐骑');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4425) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4425坐骑状态设置成功');
                            this.addTestResult('4425坐骑状态设置测试', true, '坐骑状态设置成功');
                        } else {
                            console.log(`❌ 4425坐骑状态设置失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4425坐骑状态设置测试', false, message.msg || '状态设置失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4425坐骑状态设置响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4425坐骑状态设置测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4425请求 - 设置坐骑为出战状态
            const requestData = {
                c: 4425,
                d: {
                    id: testMountId,
                    t: 2 // 2: 出战, 1: 休息
                }
            };

            console.log(`📤 发送4425请求(设置出战):`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4425坐骑状态设置测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 11. 测试4420指令 - 训练坐骑
    async testCode4420TrainMount() {
        console.log('\n🐎 步骤11: 测试4420指令 - 训练坐骑...');

        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
            this.addTestResult('4420坐骑训练测试', false, 'WebSocket未连接');
            return;
        }

        // 如果有玩家坐骑数据，使用第一个坐骑进行测试
        let testMountId = null;
        if (this.playerMountsData && this.playerMountsData.data && this.playerMountsData.data.length > 0) {
            testMountId = this.playerMountsData.data[0].id;
        } else if (this.mountListData && this.mountListData.data && this.mountListData.data.length > 0) {
            // 如果没有玩家坐骑，使用坐骑列表中的第一个坐骑（假设已购买）
            const availableMount = this.mountListData.data.find(mount => mount.s !== 0);
            if (availableMount) {
                testMountId = availableMount.id;
            }
        }

        if (!testMountId) {
            console.log('⚠️ 没有可用的坐骑进行训练测试');
            this.addTestResult('4420坐骑训练测试', false, '没有可用坐骑');
            return;
        }

        return new Promise((resolve) => {
            let responseReceived = false;

            // 设置响应监听器
            const responseHandler = (data) => {
                try {
                    const message = JSON.parse(data.toString());
                    if (message.act_id === 4420) {
                        this.ws.removeListener('message', responseHandler);
                        responseReceived = true;

                        if (message.code === 0) {
                            console.log('✅ 4420坐骑训练成功');
                            console.log(`🐎 训练结果: ${message.msg || '训练完成'}`);
                            this.addTestResult('4420坐骑训练测试', true, '坐骑训练成功');
                        } else {
                            console.log(`❌ 4420坐骑训练失败: ${message.msg || '未知错误'}`);
                            this.addTestResult('4420坐骑训练测试', false, message.msg || '训练失败');
                        }
                        resolve();
                    }
                } catch (error) {
                    console.error('❌ 4420坐骑训练响应解析失败:', error.message);
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4420坐骑训练测试', false, '响应解析失败');
                    resolve();
                }
            };

            this.ws.on('message', responseHandler);

            // 发送4420请求 - 训练坐骑
            const requestData = {
                c: 4420,
                d: {
                    id: testMountId,
                    t: "1" // 训练类型
                }
            };

            console.log(`📤 发送4420请求(训练坐骑):`, JSON.stringify(requestData, null, 2));
            this.ws.send(JSON.stringify(requestData));

            // 设置超时
            setTimeout(() => {
                if (!responseReceived) {
                    this.ws.removeListener('message', responseHandler);
                    this.addTestResult('4420坐骑训练测试', false, '请求超时');
                    resolve();
                }
            }, 10000);
        });
    }

    // 12. 验证数据结构完整性
    async validateDataStructure() {
        console.log('\n🔍 步骤12: 验证数据结构完整性...');

        let validationResults = [];

        // 验证坐骑列表数据结构
        if (this.mountListData && this.mountListData.data) {
            const mountListValidation = this.validateMountListData(this.mountListData.data);
            validationResults.push({
                name: '坐骑列表数据结构',
                result: mountListValidation
            });
        }

        // 验证玩家坐骑列表数据结构
        if (this.playerMountsData && this.playerMountsData.data) {
            const playerMountsValidation = this.validatePlayerMountsData(this.playerMountsData.data);
            validationResults.push({
                name: '玩家坐骑列表数据结构',
                result: playerMountsValidation
            });
        }

        // 验证当前出战坐骑数据结构
        if (this.activeMountData && this.activeMountData.data) {
            const activeMountValidation = this.validateActiveMountData(this.activeMountData.data);
            validationResults.push({
                name: '当前出战坐骑数据结构',
                result: activeMountValidation
            });
        }

        // 输出验证结果
        console.log('📊 数据结构验证结果:');
        validationResults.forEach(validation => {
            const status = validation.result.isValid ? '✅' : '❌';
            console.log(`${status} ${validation.name}: ${validation.result.message}`);
        });

        const allValid = validationResults.every(v => v.result.isValid);
        this.addTestResult('数据结构验证', allValid,
            allValid ? '所有数据结构验证通过' : '部分数据结构验证失败');
    }

    // 验证坐骑列表数据结构
    validateMountListData(mountList) {
        if (!Array.isArray(mountList)) {
            return { isValid: false, message: '坐骑列表不是数组格式' };
        }

        const requiredFields = ['id', 'n', 's', 't', 'g', 'hid'];
        let validCount = 0;

        mountList.forEach((mount, index) => {
            const missingFields = requiredFields.filter(field => !(field in mount));
            if (missingFields.length === 0) {
                validCount++;
            } else {
                console.log(`❌ 坐骑${index + 1}缺少字段: ${missingFields.join(', ')}`);
            }
        });

        const isValid = validCount === mountList.length;
        return {
            isValid,
            message: `${validCount}/${mountList.length}个坐骑数据结构正确`
        };
    }

    // 验证玩家坐骑列表数据结构
    validatePlayerMountsData(playerMounts) {
        if (!Array.isArray(playerMounts)) {
            return { isValid: false, message: '玩家坐骑列表不是数组格式' };
        }

        if (playerMounts.length === 0) {
            return { isValid: true, message: '玩家暂无坐骑' };
        }

        const requiredFields = ['id', 'name', 'level', 'experience', 'status', 'mountBaseId'];
        let validCount = 0;

        playerMounts.forEach((mount, index) => {
            const missingFields = requiredFields.filter(field => !(field in mount));
            if (missingFields.length === 0) {
                validCount++;
            } else {
                console.log(`❌ 玩家坐骑${index + 1}缺少字段: ${missingFields.join(', ')}`);
            }
        });

        const isValid = validCount === playerMounts.length;
        return {
            isValid,
            message: `${validCount}/${playerMounts.length}个玩家坐骑数据结构正确`
        };
    }

    // 验证当前出战坐骑数据结构
    validateActiveMountData(activeMount) {
        if (!activeMount) {
            return { isValid: true, message: '当前没有出战坐骑' };
        }

        const requiredFields = ['id', 'name', 'lvl', 'exp', 'hp', 'ap', 'sp', 'mp'];
        const missingFields = requiredFields.filter(field => !(field in activeMount));

        if (missingFields.length === 0) {
            return { isValid: true, message: '当前出战坐骑数据结构正确' };
        } else {
            return { isValid: false, message: `缺少字段: ${missingFields.join(', ')}` };
        }
    }

    // 13. 断开连接
    async testDisconnect() {
        console.log('\n🔌 步骤13: 断开WebSocket连接...');
        if (this.ws) {
            this.ws.close();
        }
        this.addTestResult('断开连接', true, '连接已断开');
    }

    // 添加测试结果
    addTestResult(testName, success, message) {
        this.testResults.push({
            test: testName,
            success: success,
            message: message,
            timestamp: new Date().toISOString()
        });
    }

    // 打印测试结果
    printTestResults() {
        console.log('\n📊 坐骑系统测试结果汇总:');
        console.log('='.repeat(60));

        let successCount = 0;
        let totalCount = this.testResults.length;

        this.testResults.forEach((result, index) => {
            const status = result.success ? '✅' : '❌';
            console.log(`${index + 1}. ${status} ${result.test}: ${result.message}`);
            if (result.success) successCount++;
        });

        console.log('='.repeat(60));
        console.log(`总计: ${successCount}/${totalCount} 项测试通过`);

        if (successCount === totalCount) {
            console.log('🎉 所有坐骑系统测试通过！');
        } else {
            console.log('⚠️  部分测试失败，请检查日志');
        }

        // 输出坐骑系统数据总结
        console.log('\n🐎 坐骑系统数据总结:');
        console.log('='.repeat(60));

        if (this.mountListData && this.mountListData.data) {
            console.log(`坐骑列表总数: ${this.mountListData.data.length}`);
            const statusCounts = { 0: 0, 1: 0, 2: 0 };
            this.mountListData.data.forEach(mount => {
                statusCounts[mount.s] = (statusCounts[mount.s] || 0) + 1;
            });
            console.log(`  未购买(0): ${statusCounts[0]}个`);
            console.log(`  未出战(1): ${statusCounts[1]}个`);
            console.log(`  已出战(2): ${statusCounts[2]}个`);
        }

        if (this.playerMountsData && this.playerMountsData.data) {
            console.log(`玩家坐骑总数: ${this.playerMountsData.data.length}`);
        }

        if (this.activeMountData && this.activeMountData.data) {
            console.log(`当前出战坐骑: ${this.activeMountData.data.name} (等级${this.activeMountData.data.lvl})`);
        }
    }

    // HTTP请求工具方法
    async makeHttpRequest(path, method = 'GET', data = null) {
        return new Promise((resolve, reject) => {
            const options = {
                hostname: CONFIG.server.host,
                port: CONFIG.server.port,
                path: path,
                method: method,
                headers: {
                    'Content-Type': 'application/json',
                }
            };

            if (data) {
                const postData = JSON.stringify(data);
                options.headers['Content-Length'] = Buffer.byteLength(postData);
            }

            const req = http.request(options, (res) => {
                let body = '';

                res.on('data', (chunk) => {
                    body += chunk;
                });

                res.on('end', () => {
                    try {
                        const responseData = JSON.parse(body);
                        if (res.statusCode >= 200 && res.statusCode < 300) {
                            resolve(responseData);
                        } else {
                            reject(new Error(`HTTP ${res.statusCode}: ${responseData.message || body}`));
                        }
                    } catch (error) {
                        if (res.statusCode >= 200 && res.statusCode < 300) {
                            resolve(body);
                        } else {
                            reject(new Error(`HTTP ${res.statusCode}: ${body}`));
                        }
                    }
                });
            });

            req.on('error', (error) => {
                reject(error);
            });

            if (data) {
                req.write(JSON.stringify(data));
            }

            req.end();
        });
    }

    // 延迟函数
    async delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}

// 运行测试
async function main() {
    const tester = new MountSystemTester();
    await tester.runTest();
}

// 如果直接运行此脚本
if (require.main === module) {
    main().catch((error) => {
        console.error('💥 坐骑系统测试脚本执行失败:', error.message);
        process.exit(1);
    });
}

module.exports = MountSystemTester;
